const fs = require('fs');
const path = require('path');
const { figmaStyles } = require('./figma-style-extractor');

// 读取配置文件
const config = JSON.parse(fs.readFileSync('./config.json', 'utf8'));

// SVG样式映射规则
const styleMapping = {
  // 颜色映射
  colors: {
    '#1E40AF': figmaStyles.colors.primary,     // 旧的蓝色 -> 新的主色
    '#3B82F6': figmaStyles.colors.primary,     // 旧的蓝色变体 -> 新的主色
    '#1890FF': figmaStyles.colors.primary,     // Ant Design蓝色 -> 新的主色
    '#40A9FF': figmaStyles.colors.primary,     // Ant Design浅蓝 -> 新的主色
    '#69C0FF': figmaStyles.colors.primary,     // Ant Design更浅蓝 -> 新的主色
    '#91CBFF': figmaStyles.colors.primary,     // Ant Design最浅蓝 -> 新的主色
    '#6B7280': figmaStyles.colors.secondary,   // 旧的灰色 -> 新的次要色
    '#9CA3AF': figmaStyles.colors.textSecondary, // 旧的浅灰 -> 新的次要文本色
    '#333333': figmaStyles.colors.text,        // 深灰色 -> 新的文本色
    '#666666': figmaStyles.colors.textSecondary, // 中灰色 -> 新的次要文本色
    '#86909C': figmaStyles.colors.textSecondary, // Ant Design灰色 -> 新的次要文本色
    '#C9CDD4': figmaStyles.colors.border,      // 浅灰色 -> 新的边框色
    '#111827': figmaStyles.colors.text,        // 旧的深色 -> 新的文本色
    '#F3F4F6': figmaStyles.colors.background,  // 旧的背景色 -> 新的背景色
    '#F8F9FA': figmaStyles.colors.background,  // 更浅的背景色 -> 新的背景色
    '#F0F2F5': figmaStyles.colors.background,  // Ant Design背景色 -> 新的背景色
    '#E6F7FF': figmaStyles.colors.background,  // Ant Design蓝色背景 -> 新的背景色
    '#F0FFF4': figmaStyles.colors.background,  // 绿色背景 -> 新的背景色
    '#FFF7E6': figmaStyles.colors.background,  // 橙色背景 -> 新的背景色
    '#FFFFFF': figmaStyles.colors.surface,     // 白色保持
    '#EF4444': figmaStyles.colors.error,       // 错误色
    '#F5222D': figmaStyles.colors.error,       // Ant Design错误色 -> 新的错误色
    '#10B981': figmaStyles.colors.success,     // 成功色
    '#52C41A': figmaStyles.colors.success,     // Ant Design成功色 -> 新的成功色
    '#F59E0B': figmaStyles.colors.warning,     // 警告色
    '#FAAD14': figmaStyles.colors.warning      // Ant Design警告色 -> 新的警告色
  },
  
  // 字体映射
  fonts: {
    'Inter': figmaStyles.typography.fontFamily.split(',')[0],
    'system-ui': figmaStyles.typography.fontFamily,
    'sans-serif': figmaStyles.typography.fontFamily,
    'Arial': figmaStyles.typography.fontFamily.split(',')[0],
    'Helvetica': figmaStyles.typography.fontFamily.split(',')[0]
  },
  
  // 圆角映射
  borderRadius: {
    '4': figmaStyles.layout.borderRadius.sm.replace('px', ''),
    '6': figmaStyles.layout.borderRadius.md.replace('px', ''),
    '8': figmaStyles.layout.borderRadius.md.replace('px', ''),
    '12': figmaStyles.layout.borderRadius.lg.replace('px', ''),
    '16': figmaStyles.layout.borderRadius.xl.replace('px', '')
  }
};

// 更新SVG文件中的样式
function updateSVGStyles(svgContent, filename) {
  let updatedContent = svgContent;
  let changeCount = 0;
  const changes = [];
  
  // 更新颜色
  Object.entries(styleMapping.colors).forEach(([oldColor, newColor]) => {
    const regex = new RegExp(oldColor.replace('#', '#'), 'gi');
    const matches = updatedContent.match(regex);
    if (matches) {
      updatedContent = updatedContent.replace(regex, newColor);
      changeCount += matches.length;
      changes.push(`颜色 ${oldColor} -> ${newColor} (${matches.length}次)`);
    }
  });
  
  // 更新字体
  Object.entries(styleMapping.fonts).forEach(([oldFont, newFont]) => {
    const regex = new RegExp(`font-family="${oldFont}"`, 'gi');
    const matches = updatedContent.match(regex);
    if (matches) {
      updatedContent = updatedContent.replace(regex, `font-family="${newFont}"`);
      changeCount += matches.length;
      changes.push(`字体 ${oldFont} -> ${newFont} (${matches.length}次)`);
    }
  });
  
  // 更新圆角
  Object.entries(styleMapping.borderRadius).forEach(([oldRadius, newRadius]) => {
    const regex = new RegExp(`rx="${oldRadius}"`, 'gi');
    const matches = updatedContent.match(regex);
    if (matches) {
      updatedContent = updatedContent.replace(regex, `rx="${newRadius}"`);
      changeCount += matches.length;
      changes.push(`圆角 ${oldRadius} -> ${newRadius} (${matches.length}次)`);
    }
    
    const ryRegex = new RegExp(`ry="${oldRadius}"`, 'gi');
    const ryMatches = updatedContent.match(ryRegex);
    if (ryMatches) {
      updatedContent = updatedContent.replace(ryRegex, `ry="${newRadius}"`);
      changeCount += ryMatches.length;
      changes.push(`圆角Y ${oldRadius} -> ${newRadius} (${ryMatches.length}次)`);
    }
  });
  
  return {
    content: updatedContent,
    changeCount,
    changes,
    hasChanges: changeCount > 0
  };
}

// 处理单个SVG文件
function processSVGFile(filePath, outputDir) {
  try {
    const filename = path.basename(filePath);
    const svgContent = fs.readFileSync(filePath, 'utf8');
    
    console.log(`处理文件: ${filename}`);
    
    const result = updateSVGStyles(svgContent, filename);
    
    if (result.hasChanges) {
      // 写入更新后的文件
      const outputPath = path.join(outputDir, filename);
      fs.writeFileSync(outputPath, result.content);
      
      console.log(`  ✓ 已更新 ${result.changeCount} 处样式`);
      result.changes.forEach(change => {
        console.log(`    - ${change}`);
      });
      
      return {
        filename,
        processed: true,
        changeCount: result.changeCount,
        changes: result.changes
      };
    } else {
      console.log(`  - 无需更新`);
      // 复制原文件
      const outputPath = path.join(outputDir, filename);
      fs.copyFileSync(filePath, outputPath);
      
      return {
        filename,
        processed: false,
        changeCount: 0,
        changes: []
      };
    }
  } catch (error) {
    console.error(`处理文件 ${filePath} 时出错:`, error.message);
    return {
      filename: path.basename(filePath),
      processed: false,
      changeCount: 0,
      changes: [],
      error: error.message
    };
  }
}

// 批量处理SVG文件
function batchUpdateSVGs() {
  try {
    console.log('开始批量更新SVG文件...');
    
    const prototypeDir = config.paths.prototypeRoot;
    const outputDir = path.join(config.paths.workingDir, 'updated-prototypes');
    
    // 创建输出目录
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true });
    }
    
    // 获取所有SVG文件
    const svgFiles = fs.readdirSync(prototypeDir)
      .filter(file => file.endsWith('.svg'))
      .map(file => path.join(prototypeDir, file));
    
    console.log(`找到 ${svgFiles.length} 个SVG文件`);
    
    const results = [];
    let totalChanges = 0;
    let processedFiles = 0;
    
    // 处理每个文件
    svgFiles.forEach(filePath => {
      const result = processSVGFile(filePath, outputDir);
      results.push(result);
      
      if (result.processed) {
        processedFiles++;
        totalChanges += result.changeCount;
      }
    });
    
    // 生成更新报告
    const report = {
      timestamp: new Date().toISOString(),
      summary: {
        totalFiles: svgFiles.length,
        processedFiles,
        totalChanges,
        outputDirectory: outputDir
      },
      styleMapping,
      fileResults: results
    };
    
    // 保存报告
    fs.writeFileSync('./validation/svg-update-report.json', JSON.stringify(report, null, 2));
    
    // 生成可读报告
    const readableReport = generateReadableReport(report);
    fs.writeFileSync('./validation/svg-update-summary.md', readableReport);
    
    console.log('\nSVG更新完成!');
    console.log(`- 总文件数: ${svgFiles.length}`);
    console.log(`- 已处理文件: ${processedFiles}`);
    console.log(`- 总更新数: ${totalChanges}`);
    console.log(`- 输出目录: ${outputDir}`);
    
    return report;
    
  } catch (error) {
    console.error('批量更新SVG失败:', error.message);
    throw error;
  }
}

// 生成可读报告
function generateReadableReport(report) {
  const { summary, fileResults } = report;
  
  let markdown = `# SVG样式更新报告\n\n`;
  markdown += `执行时间: ${report.timestamp}\n\n`;
  
  markdown += `## 更新概要\n\n`;
  markdown += `- 总文件数: ${summary.totalFiles}\n`;
  markdown += `- 已处理文件: ${summary.processedFiles}\n`;
  markdown += `- 总更新数: ${summary.totalChanges}\n`;
  markdown += `- 输出目录: ${summary.outputDirectory}\n\n`;
  
  markdown += `## 样式映射规则\n\n`;
  markdown += `### 颜色映射\n`;
  Object.entries(styleMapping.colors).forEach(([old, newColor]) => {
    markdown += `- ${old} → ${newColor}\n`;
  });
  
  markdown += `\n### 字体映射\n`;
  Object.entries(styleMapping.fonts).forEach(([old, newFont]) => {
    markdown += `- ${old} → ${newFont}\n`;
  });
  
  markdown += `\n## 文件处理详情\n\n`;
  
  const processedFiles = fileResults.filter(f => f.processed);
  const skippedFiles = fileResults.filter(f => !f.processed && !f.error);
  const errorFiles = fileResults.filter(f => f.error);
  
  if (processedFiles.length > 0) {
    markdown += `### 已更新文件 (${processedFiles.length})\n\n`;
    processedFiles.forEach(file => {
      markdown += `#### ${file.filename}\n`;
      markdown += `- 更新数量: ${file.changeCount}\n`;
      file.changes.forEach(change => {
        markdown += `  - ${change}\n`;
      });
      markdown += `\n`;
    });
  }
  
  if (skippedFiles.length > 0) {
    markdown += `### 跳过文件 (${skippedFiles.length})\n\n`;
    skippedFiles.forEach(file => {
      markdown += `- ${file.filename} (无需更新)\n`;
    });
    markdown += `\n`;
  }
  
  if (errorFiles.length > 0) {
    markdown += `### 错误文件 (${errorFiles.length})\n\n`;
    errorFiles.forEach(file => {
      markdown += `- ${file.filename}: ${file.error}\n`;
    });
  }
  
  return markdown;
}

// 主执行函数
function main() {
  try {
    const report = batchUpdateSVGs();
    console.log('\n✓ SVG样式更新任务完成');
    console.log('✓ 更新报告已生成: svg-update-report.json');
    console.log('✓ 可读报告已生成: svg-update-summary.md');
  } catch (error) {
    console.error('SVG更新失败:', error.message);
    process.exit(1);
  }
}

if (require.main === module) {
  main();
}

module.exports = { updateSVGStyles, batchUpdateSVGs, styleMapping };